#include "globale.h"
#include "../games/cls_configuration.h" // Classe de gestion du fichier de configuration

/* ----------------------------------------------------
    Fonction permettant de tracer les messages
  ----------------------------------------------------- */
void debugTrace(const char *stValue)
{

    time_t rawtime;
    struct tm * timeinfo;
    char logStr[256];

    if (cls_Configuration::haveDebugTrace() == CONFIG_DBUG_HAVE)
    {
        #ifdef WIN32
            FILE *ficFichierLancement;
        #endif

        // On recupere l'heure du systeme
        time (&rawtime);
        #ifdef WIN32
            timeinfo = localtime (&rawtime);
        #else
            timeinfo = gmtime (&rawtime);
        #endif
        timeinfo = localtime (&rawtime);

        sprintf(logStr, "TRACE %02d:%02d:%02d ----> %s\n", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, stValue);

        #ifdef WIN32
            // On ecrit cette chaine dans le fichier
            ficFichierLancement=fopen("stdout.log","a");
            fprintf(ficFichierLancement,"%s",logStr);
            fclose(ficFichierLancement);
        #endif

        // On affiche dans la sortie
        printf("%s", logStr);
    }
}

/* ----------------------------------------------------
    Chargement d'une image
  ----------------------------------------------------- */
// SDL est capable d'appliquer une image d'un format différent sur une autre,
// il faut pour cela qu'il change de lui même le format "à l'arrache"
// ce qui peut causer quelques ralentissements...
// On retourne donc un format d'image optimizé aux nombres de couleurs de l'utilisateur.
SDL_Surface *load_image(string filename)
{
	//Surface tampon qui nous servira pour charger l'image
	SDL_Surface* loadedImage = NULL;

	//L'image optimisée qu'on va utiliser
	SDL_Surface* optimizedImage = NULL;

	//Chargement de l'image
	loadedImage = IMG_Load( filename.c_str() );

	//Si le chargement se passe bien
	if( loadedImage != NULL ) {
		//Création de l'image optimisée
		optimizedImage = SDL_DisplayFormatAlpha( loadedImage );

		//Libération de l'ancienne image
		SDL_FreeSurface( loadedImage );
	}

char stMsgdebug[256];
sprintf(stMsgdebug, "Optimization Image [%s] (OK)", filename.c_str());
debugTrace(stMsgdebug);

	//On retourne l'image optimisée
	return optimizedImage;
}


/* ----------------------------------------------------
    Retourne si le point X, Y est dans la boite
  ----------------------------------------------------- */
bool isInBox(SDL_Rect sdlR_PositionObjet_XY, int mouseX, int mouseY)
{
    if (((sdlR_PositionObjet_XY.x < mouseX) && (sdlR_PositionObjet_XY.x + sdlR_PositionObjet_XY.w > mouseX))
        && ((sdlR_PositionObjet_XY.y < mouseY) && (sdlR_PositionObjet_XY.y + sdlR_PositionObjet_XY.h > mouseY)))
    {
        return true;
    }

    return false;
}

/* ----------------------------------------------------
    Join un repertoire et un nom de fichier
  ----------------------------------------------------- */
string join_pathFile(const string &dir, const string &file)
{
    return dir + '/' + file;
}



#define SPACES " \t\r\n"
/* ----------------------------------------------------
    Fonction de Trim
  ----------------------------------------------------- */
string strTrim_right (const string & s)
{
    string d (s);
    string::size_type i (d.find_last_not_of (" \t\r\n"));
    if (i == string::npos)
        return "";
    else
        return d.erase (d.find_last_not_of (" \t\r\n") + 1) ;
}  // end of trim_right

string strTrim_left (const string & s)
{
    string d (s);
    return d.erase (0, s.find_first_not_of (" \t\r\n")) ;
}  // end of trim_left

string strTrim (const string & s)
{
    string d (s);
    return strTrim_left (strTrim_right (d)) ;
}  // end of trim



/* ----------------------------------------------------
    Fonction de découpage de chaine
  ----------------------------------------------------- */
void strSplit(const string& chaine, vector<string>& vecteur, const string& separateur)
{
    // Skip separateur at beginning.
    string::size_type lastPos = chaine.find_first_not_of(separateur, 0);
    // Find first "non-delimiter".
    string::size_type pos     = chaine.find_first_of(separateur, lastPos);

    while (string::npos != pos || string::npos != lastPos)
    {
        // Found a token, add it to the vector.
        vecteur.push_back(chaine.substr(lastPos, pos - lastPos));
        // Skip separateur.  Note the "not_of"
        lastPos = chaine.find_first_not_of(separateur, pos);
        // Find next "non-delimiter"
        pos = chaine.find_first_of(separateur, lastPos);
    }
}

/* ----------------------------------------------------
    Fonction de convertion d'un objet string en long
  ----------------------------------------------------- */
bool strToLong(const string& chaine, long& destination )
{
    // créer un flux à partir de la chaîne donnée
    std::istringstream iss(chaine);
    // tenter la conversion vers Dest
    return iss >> destination != 0;
}
